import pysrt
import pandas as pd
import re
import spacy

#%%
import subprocess
#%%
print(subprocess.getoutput("python -m spacy download en_core_web_sm"))
nlp = spacy.load('en_core_web_sm')

subs = pysrt.open("ides_of_march.srt", encoding="latin-1")

DF = pd.DataFrame([
  {
    "Text": sub.text,
    "Start": sub.start.seconds,
    "End": sub.end.seconds
} for sub in subs])

DF.head()

# Regular expression pattern to identify suspicious characters
RE_SUSPICIOUS = re.compile(r'[&#<>{}\-\[\]\\]')

# Function to calculate the proportion of suspicious characters in a text
def impurity(text, min_len=0):
    """Returns the share of suspicious characters in a text"""
    if text is None or len(text) < min_len:
        return 0
    else:
        # Calculating the impurity score
        impurity_score = (len(RE_SUSPICIOUS.findall(text)) / len(text)) * 100
        return impurity_score

# Applying the impurity function to the 'Text' column of DataFrame DF
DF['score'] = DF['Text'].apply(impurity)

# Sorting the DataFrame based on the 'score' column in descending order and displaying the top 10 entries
DF.sort_values(['score'], ascending=[False]).head(10)

# Removing all the previously defined suspisious characters using the regex function. 
DF['clean_text'] = DF['clean'].apply(lambda x: re.sub(RE_SUSPICIOUS, ' ', x))
DF.sort_values(['score'], ascending = [False]).head(10)

# Reexamining impurity after removing suspicious characters
DF['clean_text'].apply(impurity).sort_values(ascending=[False]).head(10)

# Extracting spaCy tags for words in the 'clean_text' column
spacy_tags = []

# Iterating through each row in the 'clean_text' column
for row in DF['clean_text'].to_list():
    # Tokenizing the text using spaCy
    for word in nlp(row):
        # Excluding tokens that are only spaces
        if not word.is_space:
            # Appending word, specific tag, and universal tag to the list
            spacy_tags.append((str(word), str(word.tag_), str(word.pos_)))

# Creating a DataFrame DF_tags from the spaCy tags list
DF_tags = pd.DataFrame(spacy_tags, columns=['word', 'specific', 'universal'])
DF_tags.head()

# Counting the most common part of speech (universal) in the DataFrame DF_tags
DF_tags['universal'].value_counts()

# Analyzing words that have multiple parts of speech
pd.crosstab(DF_tags['word'], DF_tags['universal'])

# Counting the occurrences of each word and sorting to find the top 10 most frequent words
word_counts = DF_tags.groupby('word')['universal'].count().reset_index()
word_counts.sort_values(by='universal', ascending=False, inplace=True)
top_words = word_counts.head(10)
top_words

# Filtering for nouns and verbs and finding the most common ones
nouns_verbs_df = DF_tags[(DF_tags['universal'] == 'NOUN') | (DF_tags['universal'] == 'VERB')]

# Finding the most common nouns
most_common_nouns = nouns_verbs_df[nouns_verbs_df['universal'] == 'NOUN']['word'].value_counts().head(10)

# Finding the most common verbs
most_common_verbs = nouns_verbs_df[nouns_verbs_df['universal'] == 'VERB']['word'].value_counts().head(10)

# Displaying the results for most common nouns
print("Most Common Nouns:")
most_common_nouns

print("\nMost Common Verbs:")
print(most_common_verbs)

import textacy
import networkx as nx
from matplotlib import pyplot as plt
from itertools import chain

# Combining text from the 'clean_text' column
combined_doc = " ".join(DF['clean_text'].to_list())

# Building an English language model for textacy
en = textacy.load_spacy_lang("en_core_web_sm", disable=("parser"))

# Building a processor for textacy using spaCy and processing text
doc = textacy.make_spacy_doc(combined_doc, lang=en)

# Extracting key phrases and their TextRank scores from the subtitles
key_phrases_textrank = textacy.extract.keyterms.textrank(doc)
key_phrases_textrank

# Combining like key phrases to reduce redundancy and improve interpretability
# Using textacy's function to aggregate term variants

terms = set([term for term, weight in textacy.extract.keyterms.textrank(doc)])
textacy.extract.utils.aggregate_term_variants(terms)

# Extracting named entities and their types using spaCy
spacy_ner_tagged = [(ent, ent.label_) for ent in nlp(combined_doc).ents]

# Creating a DataFrame DF_tags with named entities and their types
DF_tags = pd.DataFrame(spacy_ner_tagged, columns=['word', 'entity'])
DF_tags.head(5)

# Summarizing named entity types and their counts in the DataFrame DF_tags
DF_tags['entity'].value_counts()

# Processing DataFrame to find every pairwise combination of entities of interest using spaCy
# Define the entity types of interest (e.g., "PERSON")
ent_types = ["PERSON"]

# Empty list to store pairwise combinations
stored_entities = []

# Function to extract entities and their pairwise combinations
def get_entities(x):
    """
    Grabs the names using spaCy's entity labeler
    """
    # Get all the entities in this row
    processed = nlp(x)
    # Get the tokens for each sentence
    tokens = [word.text for word in processed]
    # Get all the entities for the specified types
    temp = [(ent.text, ent.label_) for ent in processed.ents if ent.label_ in ent_types]
    # Proceed only if this row has at least two entities
    if len(temp) > 1:
        # Find all the combinations of pairs
        temp2 = list(combinations(temp, 2))
        # For each pair combination
        for (person1, person2) in temp2:
            # Find the names in person 1
            person1_words = [word.text for word in nlp(person1[0])]
            # Find the token numbers for person 1
            person1_ids = [i for i, val in enumerate(tokens) if val in person1_words]
            # Output in (start, stop) token tuple format
            if len(person1_words) > 1:
                person1_ids2 = tuple(idx for idx in person1_ids)
            else:
                id_1 = [idx for idx in person1_ids]
                person1_ids2 = (id_1[0], id_1[0])

            # Do the same thing with person 2
            person2_words = [word.text for word in nlp(person2[0])]
            person2_ids = [i for i, val in enumerate(tokens) if val in person2_words]
            if len(person2_words) > 1:
                person2_ids2 = tuple(idx for idx in person2_ids)
            else:
                id_2 = [idx for idx in person2_ids]
                person2_ids2 = (id_2[0], id_2[0])

            # Store all this in a list
            stored_entities.append(
                [x,  # Original text
                 tokens,  # Tokens
                 person1[0],  # Person 1 name
                 person2[0],  # Person 2 name
                 person1_ids2,  # Person 1 id token tuple
                 person2_ids2  # Person 2 id token tuple
                 ])

# Apply the get_entities function to the 'clean_text' column
DF['clean_text'].apply(get_entities)

# Create a DataFrame in Snorkel's structure
DF_dev = pd.DataFrame(stored_entities, columns=["sentence", "tokens", "person1", "person2", "person1_word_idx", "person2_word_idx"])
DF_dev[["sentence", "person1", "person2", "tokens"]].head(10)

# Filter DataFrame for character relations and count co-occurrences
DF_characters = DF_combo[DF_combo['character'] > 0]
DF_characters = DF_characters[["person1", "person2", "character"]]
co_character = DF_characters.groupby(['person1', 'person2']).agg('count').reset_index().rename(columns={"character": "weight"})
co_character.head(10)

# Print knowledge graph of the entities (persons) linked together in text
graph = nx.from_pandas_edgelist(
           co_character[['person1', 'person2', 'weight']],
           source='person1', target='person2', edge_attr=True)

pos = nx.kamada_kawai_layout(graph, weight='weight')

_ = plt.figure(figsize=(10, 10))
nx.draw(graph, pos, 
        node_size=1000, 
        node_color='skyblue',
        alpha=0.8,
        with_labels=True)
plt.title('Graph Visualization', size=15)

for (node1, node2, data) in graph.edges(data=True):
    width = data['weight'] 
    _ = nx.draw_networkx_edges(graph, pos,
                               edgelist=[(node1, node2)],
                               width=width,
                               edge_color='#505050',
                               alpha=0.5)

plt.show()
plt.close()